// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: chat.proto

#ifndef PROTOBUF_chat_2eproto__INCLUDED
#define PROTOBUF_chat_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
class AuthReqBody;
class AuthReqBodyDefaultTypeInternal;
extern AuthReqBodyDefaultTypeInternal _AuthReqBody_default_instance_;
class AuthRespBody;
class AuthRespBodyDefaultTypeInternal;
extern AuthRespBodyDefaultTypeInternal _AuthRespBody_default_instance_;
class BeginToLiveReqBody;
class BeginToLiveReqBodyDefaultTypeInternal;
extern BeginToLiveReqBodyDefaultTypeInternal _BeginToLiveReqBody_default_instance_;
class BeginToLiveRespBody;
class BeginToLiveRespBodyDefaultTypeInternal;
extern BeginToLiveRespBodyDefaultTypeInternal _BeginToLiveRespBody_default_instance_;
class ChatReqBody;
class ChatReqBodyDefaultTypeInternal;
extern ChatReqBodyDefaultTypeInternal _ChatReqBody_default_instance_;
class ChatRespBody;
class ChatRespBodyDefaultTypeInternal;
extern ChatRespBodyDefaultTypeInternal _ChatRespBody_default_instance_;
class Client;
class ClientDefaultTypeInternal;
extern ClientDefaultTypeInternal _Client_default_instance_;
class ClientPageReqBody;
class ClientPageReqBodyDefaultTypeInternal;
extern ClientPageReqBodyDefaultTypeInternal _ClientPageReqBody_default_instance_;
class ClientPageRespBody;
class ClientPageRespBodyDefaultTypeInternal;
extern ClientPageRespBodyDefaultTypeInternal _ClientPageRespBody_default_instance_;
class EndLiveReqBody;
class EndLiveReqBodyDefaultTypeInternal;
extern EndLiveReqBodyDefaultTypeInternal _EndLiveReqBody_default_instance_;
class EndLiveRespBody;
class EndLiveRespBodyDefaultTypeInternal;
extern EndLiveRespBodyDefaultTypeInternal _EndLiveRespBody_default_instance_;
class ExitGroupNotifyRespBody;
class ExitGroupNotifyRespBodyDefaultTypeInternal;
extern ExitGroupNotifyRespBodyDefaultTypeInternal _ExitGroupNotifyRespBody_default_instance_;
class JoinGroupNotifyRespBody;
class JoinGroupNotifyRespBodyDefaultTypeInternal;
extern JoinGroupNotifyRespBodyDefaultTypeInternal _JoinGroupNotifyRespBody_default_instance_;
class JoinGroupReqBody;
class JoinGroupReqBodyDefaultTypeInternal;
extern JoinGroupReqBodyDefaultTypeInternal _JoinGroupReqBody_default_instance_;
class JoinGroupRespBody;
class JoinGroupRespBodyDefaultTypeInternal;
extern JoinGroupRespBodyDefaultTypeInternal _JoinGroupRespBody_default_instance_;
class LoginReqBody;
class LoginReqBodyDefaultTypeInternal;
extern LoginReqBodyDefaultTypeInternal _LoginReqBody_default_instance_;
class LoginRespBody;
class LoginRespBodyDefaultTypeInternal;
extern LoginRespBodyDefaultTypeInternal _LoginRespBody_default_instance_;
class User;
class UserDefaultTypeInternal;
extern UserDefaultTypeInternal _User_default_instance_;

namespace protobuf_chat_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::uint32 offsets[];
  static void InitDefaultsImpl();
  static void Shutdown();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_chat_2eproto

enum DeviceType {
  DEVICE_TYPE_UNKNOW = 0,
  DEVICE_TYPE_PC = 1,
  DEVICE_TYPE_ANDROID = 2,
  DEVICE_TYPE_IOS = 3,
  DeviceType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  DeviceType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool DeviceType_IsValid(int value);
const DeviceType DeviceType_MIN = DEVICE_TYPE_UNKNOW;
const DeviceType DeviceType_MAX = DEVICE_TYPE_IOS;
const int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;

const ::google::protobuf::EnumDescriptor* DeviceType_descriptor();
inline const ::std::string& DeviceType_Name(DeviceType value) {
  return ::google::protobuf::internal::NameOfEnum(
    DeviceType_descriptor(), value);
}
inline bool DeviceType_Parse(
    const ::std::string& name, DeviceType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DeviceType>(
    DeviceType_descriptor(), name, value);
}
enum Command {
  COMMAND_UNKNOW = 0,
  COMMAND_HANDSHAKE_REQ = 1,
  COMMAND_HANDSHAKE_RESP = 2,
  COMMAND_AUTH_REQ = 3,
  COMMAND_AUTH_RESP = 4,
  COMMAND_JOIN_GROUP_REQ = 5,
  COMMAND_JOIN_GROUP_RESP = 6,
  COMMAND_JOIN_GROUP_NOTIFY_RESP = 7,
  COMMAND_EXIT_GROUP_NOTIFY_RESP = 20,
  COMMAND_CHAT_REQ = 8,
  COMMAND_CHAT_RESP = 9,
  COMMAND_START_SHOW_REQ = 10,
  COMMAND_START_SHOW_RESP = 11,
  COMMAND_END_SHOW_REQ = 12,
  COMMAND_END_SHOW_NOTIFY_RESP = 13,
  COMMAND_HEARTBEAT_REQ = 14,
  COMMAND_CLOSE_REQ = 15,
  COMMAND_CLIENT_PAGE_REQ = 16,
  COMMAND_CLIENT_PAGE_RESP = 17,
  COMMAND_LOGIN_REQ = 18,
  COMMAND_LOGIN_RESP = 19,
  COMMAND_CANCEL_MSG_REQ = 21,
  COMMAND_CANCEL_MSG_RESP = 22,
  Command_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  Command_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool Command_IsValid(int value);
const Command Command_MIN = COMMAND_UNKNOW;
const Command Command_MAX = COMMAND_CANCEL_MSG_RESP;
const int Command_ARRAYSIZE = Command_MAX + 1;

const ::google::protobuf::EnumDescriptor* Command_descriptor();
inline const ::std::string& Command_Name(Command value) {
  return ::google::protobuf::internal::NameOfEnum(
    Command_descriptor(), value);
}
inline bool Command_Parse(
    const ::std::string& name, Command* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Command>(
    Command_descriptor(), name, value);
}
enum JoinGroupResult {
  JOIN_GROUP_RESULT_UNKNOW = 0,
  JOIN_GROUP_RESULT_OK = 1,
  JOIN_GROUP_RESULT_NOT_EXIST = 2,
  JOIN_GROUP_RESULT_GROUP_FULL = 3,
  JOIN_GROUP_RESULT_IN_BACKLIST = 4,
  JOIN_GROUP_RESULT_TAKEOUTED = 5,
  JoinGroupResult_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  JoinGroupResult_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool JoinGroupResult_IsValid(int value);
const JoinGroupResult JoinGroupResult_MIN = JOIN_GROUP_RESULT_UNKNOW;
const JoinGroupResult JoinGroupResult_MAX = JOIN_GROUP_RESULT_TAKEOUTED;
const int JoinGroupResult_ARRAYSIZE = JoinGroupResult_MAX + 1;

const ::google::protobuf::EnumDescriptor* JoinGroupResult_descriptor();
inline const ::std::string& JoinGroupResult_Name(JoinGroupResult value) {
  return ::google::protobuf::internal::NameOfEnum(
    JoinGroupResult_descriptor(), value);
}
inline bool JoinGroupResult_Parse(
    const ::std::string& name, JoinGroupResult* value) {
  return ::google::protobuf::internal::ParseNamedEnum<JoinGroupResult>(
    JoinGroupResult_descriptor(), name, value);
}
enum ChatType {
  CHAT_TYPE_UNKNOW = 0,
  CHAT_TYPE_PUBLIC = 1,
  CHAT_TYPE_PRIVATE = 2,
  ChatType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  ChatType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool ChatType_IsValid(int value);
const ChatType ChatType_MIN = CHAT_TYPE_UNKNOW;
const ChatType ChatType_MAX = CHAT_TYPE_PRIVATE;
const int ChatType_ARRAYSIZE = ChatType_MAX + 1;

const ::google::protobuf::EnumDescriptor* ChatType_descriptor();
inline const ::std::string& ChatType_Name(ChatType value) {
  return ::google::protobuf::internal::NameOfEnum(
    ChatType_descriptor(), value);
}
inline bool ChatType_Parse(
    const ::std::string& name, ChatType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ChatType>(
    ChatType_descriptor(), name, value);
}
// ===================================================================

class User : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:User) */ {
 public:
  User();
  virtual ~User();

  User(const User& from);

  inline User& operator=(const User& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const User& default_instance();

  static inline const User* internal_default_instance() {
    return reinterpret_cast<const User*>(
               &_User_default_instance_);
  }

  void Swap(User* other);

  // implements Message ----------------------------------------------

  inline User* New() const PROTOBUF_FINAL { return New(NULL); }

  User* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const User& from);
  void MergeFrom(const User& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(User* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string nick = 2;
  void clear_nick();
  static const int kNickFieldNumber = 2;
  const ::std::string& nick() const;
  void set_nick(const ::std::string& value);
  #if LANG_CXX11
  void set_nick(::std::string&& value);
  #endif
  void set_nick(const char* value);
  void set_nick(const char* value, size_t size);
  ::std::string* mutable_nick();
  ::std::string* release_nick();
  void set_allocated_nick(::std::string* nick);

  // string avatar = 3;
  void clear_avatar();
  static const int kAvatarFieldNumber = 3;
  const ::std::string& avatar() const;
  void set_avatar(const ::std::string& value);
  #if LANG_CXX11
  void set_avatar(::std::string&& value);
  #endif
  void set_avatar(const char* value);
  void set_avatar(const char* value, size_t size);
  ::std::string* mutable_avatar();
  ::std::string* release_avatar();
  void set_allocated_avatar(::std::string* avatar);

  // int64 id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  ::google::protobuf::int64 id() const;
  void set_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:User)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr nick_;
  ::google::protobuf::internal::ArenaStringPtr avatar_;
  ::google::protobuf::int64 id_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Client : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Client) */ {
 public:
  Client();
  virtual ~Client();

  Client(const Client& from);

  inline Client& operator=(const Client& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Client& default_instance();

  static inline const Client* internal_default_instance() {
    return reinterpret_cast<const Client*>(
               &_Client_default_instance_);
  }

  void Swap(Client* other);

  // implements Message ----------------------------------------------

  inline Client* New() const PROTOBUF_FINAL { return New(NULL); }

  Client* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Client& from);
  void MergeFrom(const Client& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(Client* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string id = 1;
  void clear_id();
  static const int kIdFieldNumber = 1;
  const ::std::string& id() const;
  void set_id(const ::std::string& value);
  #if LANG_CXX11
  void set_id(::std::string&& value);
  #endif
  void set_id(const char* value);
  void set_id(const char* value, size_t size);
  ::std::string* mutable_id();
  ::std::string* release_id();
  void set_allocated_id(::std::string* id);

  // string ip = 2;
  void clear_ip();
  static const int kIpFieldNumber = 2;
  const ::std::string& ip() const;
  void set_ip(const ::std::string& value);
  #if LANG_CXX11
  void set_ip(::std::string&& value);
  #endif
  void set_ip(const char* value);
  void set_ip(const char* value, size_t size);
  ::std::string* mutable_ip();
  ::std::string* release_ip();
  void set_allocated_ip(::std::string* ip);

  // string region = 5;
  void clear_region();
  static const int kRegionFieldNumber = 5;
  const ::std::string& region() const;
  void set_region(const ::std::string& value);
  #if LANG_CXX11
  void set_region(::std::string&& value);
  #endif
  void set_region(const char* value);
  void set_region(const char* value, size_t size);
  ::std::string* mutable_region();
  ::std::string* release_region();
  void set_allocated_region(::std::string* region);

  // string useragent = 6;
  void clear_useragent();
  static const int kUseragentFieldNumber = 6;
  const ::std::string& useragent() const;
  void set_useragent(const ::std::string& value);
  #if LANG_CXX11
  void set_useragent(::std::string&& value);
  #endif
  void set_useragent(const char* value);
  void set_useragent(const char* value, size_t size);
  ::std::string* mutable_useragent();
  ::std::string* release_useragent();
  void set_allocated_useragent(::std::string* useragent);

  // .User user = 4;
  bool has_user() const;
  void clear_user();
  static const int kUserFieldNumber = 4;
  const ::User& user() const;
  ::User* mutable_user();
  ::User* release_user();
  void set_allocated_user(::User* user);

  // int32 port = 3;
  void clear_port();
  static const int kPortFieldNumber = 3;
  ::google::protobuf::int32 port() const;
  void set_port(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Client)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr id_;
  ::google::protobuf::internal::ArenaStringPtr ip_;
  ::google::protobuf::internal::ArenaStringPtr region_;
  ::google::protobuf::internal::ArenaStringPtr useragent_;
  ::User* user_;
  ::google::protobuf::int32 port_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class AuthReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:AuthReqBody) */ {
 public:
  AuthReqBody();
  virtual ~AuthReqBody();

  AuthReqBody(const AuthReqBody& from);

  inline AuthReqBody& operator=(const AuthReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AuthReqBody& default_instance();

  static inline const AuthReqBody* internal_default_instance() {
    return reinterpret_cast<const AuthReqBody*>(
               &_AuthReqBody_default_instance_);
  }

  void Swap(AuthReqBody* other);

  // implements Message ----------------------------------------------

  inline AuthReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  AuthReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const AuthReqBody& from);
  void MergeFrom(const AuthReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(AuthReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string token = 1;
  void clear_token();
  static const int kTokenFieldNumber = 1;
  const ::std::string& token() const;
  void set_token(const ::std::string& value);
  #if LANG_CXX11
  void set_token(::std::string&& value);
  #endif
  void set_token(const char* value);
  void set_token(const char* value, size_t size);
  ::std::string* mutable_token();
  ::std::string* release_token();
  void set_allocated_token(::std::string* token);

  // string deviceId = 2;
  void clear_deviceid();
  static const int kDeviceIdFieldNumber = 2;
  const ::std::string& deviceid() const;
  void set_deviceid(const ::std::string& value);
  #if LANG_CXX11
  void set_deviceid(::std::string&& value);
  #endif
  void set_deviceid(const char* value);
  void set_deviceid(const char* value, size_t size);
  ::std::string* mutable_deviceid();
  ::std::string* release_deviceid();
  void set_allocated_deviceid(::std::string* deviceid);

  // string cid = 5;
  void clear_cid();
  static const int kCidFieldNumber = 5;
  const ::std::string& cid() const;
  void set_cid(const ::std::string& value);
  #if LANG_CXX11
  void set_cid(::std::string&& value);
  #endif
  void set_cid(const char* value);
  void set_cid(const char* value, size_t size);
  ::std::string* mutable_cid();
  ::std::string* release_cid();
  void set_allocated_cid(::std::string* cid);

  // string appVersion = 6;
  void clear_appversion();
  static const int kAppVersionFieldNumber = 6;
  const ::std::string& appversion() const;
  void set_appversion(const ::std::string& value);
  #if LANG_CXX11
  void set_appversion(::std::string&& value);
  #endif
  void set_appversion(const char* value);
  void set_appversion(const char* value, size_t size);
  ::std::string* mutable_appversion();
  ::std::string* release_appversion();
  void set_allocated_appversion(::std::string* appversion);

  // string deviceInfo = 7;
  void clear_deviceinfo();
  static const int kDeviceInfoFieldNumber = 7;
  const ::std::string& deviceinfo() const;
  void set_deviceinfo(const ::std::string& value);
  #if LANG_CXX11
  void set_deviceinfo(::std::string&& value);
  #endif
  void set_deviceinfo(const char* value);
  void set_deviceinfo(const char* value, size_t size);
  ::std::string* mutable_deviceinfo();
  ::std::string* release_deviceinfo();
  void set_allocated_deviceinfo(::std::string* deviceinfo);

  // string sign = 8;
  void clear_sign();
  static const int kSignFieldNumber = 8;
  const ::std::string& sign() const;
  void set_sign(const ::std::string& value);
  #if LANG_CXX11
  void set_sign(::std::string&& value);
  #endif
  void set_sign(const char* value);
  void set_sign(const char* value, size_t size);
  ::std::string* mutable_sign();
  ::std::string* release_sign();
  void set_allocated_sign(::std::string* sign);

  // int64 seq = 3;
  void clear_seq();
  static const int kSeqFieldNumber = 3;
  ::google::protobuf::int64 seq() const;
  void set_seq(::google::protobuf::int64 value);

  // .DeviceType deviceType = 4;
  void clear_devicetype();
  static const int kDeviceTypeFieldNumber = 4;
  ::DeviceType devicetype() const;
  void set_devicetype(::DeviceType value);

  // @@protoc_insertion_point(class_scope:AuthReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr token_;
  ::google::protobuf::internal::ArenaStringPtr deviceid_;
  ::google::protobuf::internal::ArenaStringPtr cid_;
  ::google::protobuf::internal::ArenaStringPtr appversion_;
  ::google::protobuf::internal::ArenaStringPtr deviceinfo_;
  ::google::protobuf::internal::ArenaStringPtr sign_;
  ::google::protobuf::int64 seq_;
  int devicetype_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class AuthRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:AuthRespBody) */ {
 public:
  AuthRespBody();
  virtual ~AuthRespBody();

  AuthRespBody(const AuthRespBody& from);

  inline AuthRespBody& operator=(const AuthRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AuthRespBody& default_instance();

  static inline const AuthRespBody* internal_default_instance() {
    return reinterpret_cast<const AuthRespBody*>(
               &_AuthRespBody_default_instance_);
  }

  void Swap(AuthRespBody* other);

  // implements Message ----------------------------------------------

  inline AuthRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  AuthRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const AuthRespBody& from);
  void MergeFrom(const AuthRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(AuthRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:AuthRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class LoginReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:LoginReqBody) */ {
 public:
  LoginReqBody();
  virtual ~LoginReqBody();

  LoginReqBody(const LoginReqBody& from);

  inline LoginReqBody& operator=(const LoginReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LoginReqBody& default_instance();

  static inline const LoginReqBody* internal_default_instance() {
    return reinterpret_cast<const LoginReqBody*>(
               &_LoginReqBody_default_instance_);
  }

  void Swap(LoginReqBody* other);

  // implements Message ----------------------------------------------

  inline LoginReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  LoginReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const LoginReqBody& from);
  void MergeFrom(const LoginReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(LoginReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string loginname = 1;
  void clear_loginname();
  static const int kLoginnameFieldNumber = 1;
  const ::std::string& loginname() const;
  void set_loginname(const ::std::string& value);
  #if LANG_CXX11
  void set_loginname(::std::string&& value);
  #endif
  void set_loginname(const char* value);
  void set_loginname(const char* value, size_t size);
  ::std::string* mutable_loginname();
  ::std::string* release_loginname();
  void set_allocated_loginname(::std::string* loginname);

  // string password = 2;
  void clear_password();
  static const int kPasswordFieldNumber = 2;
  const ::std::string& password() const;
  void set_password(const ::std::string& value);
  #if LANG_CXX11
  void set_password(::std::string&& value);
  #endif
  void set_password(const char* value);
  void set_password(const char* value, size_t size);
  ::std::string* mutable_password();
  ::std::string* release_password();
  void set_allocated_password(::std::string* password);

  // string token = 3;
  void clear_token();
  static const int kTokenFieldNumber = 3;
  const ::std::string& token() const;
  void set_token(const ::std::string& value);
  #if LANG_CXX11
  void set_token(::std::string&& value);
  #endif
  void set_token(const char* value);
  void set_token(const char* value, size_t size);
  ::std::string* mutable_token();
  ::std::string* release_token();
  void set_allocated_token(::std::string* token);

  // @@protoc_insertion_point(class_scope:LoginReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr loginname_;
  ::google::protobuf::internal::ArenaStringPtr password_;
  ::google::protobuf::internal::ArenaStringPtr token_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class LoginRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:LoginRespBody) */ {
 public:
  LoginRespBody();
  virtual ~LoginRespBody();

  LoginRespBody(const LoginRespBody& from);

  inline LoginRespBody& operator=(const LoginRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const LoginRespBody& default_instance();

  static inline const LoginRespBody* internal_default_instance() {
    return reinterpret_cast<const LoginRespBody*>(
               &_LoginRespBody_default_instance_);
  }

  void Swap(LoginRespBody* other);

  // implements Message ----------------------------------------------

  inline LoginRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  LoginRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const LoginRespBody& from);
  void MergeFrom(const LoginRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(LoginRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string token = 1;
  void clear_token();
  static const int kTokenFieldNumber = 1;
  const ::std::string& token() const;
  void set_token(const ::std::string& value);
  #if LANG_CXX11
  void set_token(::std::string&& value);
  #endif
  void set_token(const char* value);
  void set_token(const char* value, size_t size);
  ::std::string* mutable_token();
  ::std::string* release_token();
  void set_allocated_token(::std::string* token);

  // .User user = 2;
  bool has_user() const;
  void clear_user();
  static const int kUserFieldNumber = 2;
  const ::User& user() const;
  ::User* mutable_user();
  ::User* release_user();
  void set_allocated_user(::User* user);

  // @@protoc_insertion_point(class_scope:LoginRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr token_;
  ::User* user_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class JoinGroupReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:JoinGroupReqBody) */ {
 public:
  JoinGroupReqBody();
  virtual ~JoinGroupReqBody();

  JoinGroupReqBody(const JoinGroupReqBody& from);

  inline JoinGroupReqBody& operator=(const JoinGroupReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const JoinGroupReqBody& default_instance();

  static inline const JoinGroupReqBody* internal_default_instance() {
    return reinterpret_cast<const JoinGroupReqBody*>(
               &_JoinGroupReqBody_default_instance_);
  }

  void Swap(JoinGroupReqBody* other);

  // implements Message ----------------------------------------------

  inline JoinGroupReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  JoinGroupReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const JoinGroupReqBody& from);
  void MergeFrom(const JoinGroupReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(JoinGroupReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string group = 1;
  void clear_group();
  static const int kGroupFieldNumber = 1;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // @@protoc_insertion_point(class_scope:JoinGroupReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class JoinGroupRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:JoinGroupRespBody) */ {
 public:
  JoinGroupRespBody();
  virtual ~JoinGroupRespBody();

  JoinGroupRespBody(const JoinGroupRespBody& from);

  inline JoinGroupRespBody& operator=(const JoinGroupRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const JoinGroupRespBody& default_instance();

  static inline const JoinGroupRespBody* internal_default_instance() {
    return reinterpret_cast<const JoinGroupRespBody*>(
               &_JoinGroupRespBody_default_instance_);
  }

  void Swap(JoinGroupRespBody* other);

  // implements Message ----------------------------------------------

  inline JoinGroupRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  JoinGroupRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const JoinGroupRespBody& from);
  void MergeFrom(const JoinGroupRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(JoinGroupRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string group = 2;
  void clear_group();
  static const int kGroupFieldNumber = 2;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // .JoinGroupResult result = 1;
  void clear_result();
  static const int kResultFieldNumber = 1;
  ::JoinGroupResult result() const;
  void set_result(::JoinGroupResult value);

  // @@protoc_insertion_point(class_scope:JoinGroupRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  int result_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class JoinGroupNotifyRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:JoinGroupNotifyRespBody) */ {
 public:
  JoinGroupNotifyRespBody();
  virtual ~JoinGroupNotifyRespBody();

  JoinGroupNotifyRespBody(const JoinGroupNotifyRespBody& from);

  inline JoinGroupNotifyRespBody& operator=(const JoinGroupNotifyRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const JoinGroupNotifyRespBody& default_instance();

  static inline const JoinGroupNotifyRespBody* internal_default_instance() {
    return reinterpret_cast<const JoinGroupNotifyRespBody*>(
               &_JoinGroupNotifyRespBody_default_instance_);
  }

  void Swap(JoinGroupNotifyRespBody* other);

  // implements Message ----------------------------------------------

  inline JoinGroupNotifyRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  JoinGroupNotifyRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const JoinGroupNotifyRespBody& from);
  void MergeFrom(const JoinGroupNotifyRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(JoinGroupNotifyRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string group = 2;
  void clear_group();
  static const int kGroupFieldNumber = 2;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // .Client client = 1;
  bool has_client() const;
  void clear_client();
  static const int kClientFieldNumber = 1;
  const ::Client& client() const;
  ::Client* mutable_client();
  ::Client* release_client();
  void set_allocated_client(::Client* client);

  // @@protoc_insertion_point(class_scope:JoinGroupNotifyRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::Client* client_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ExitGroupNotifyRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ExitGroupNotifyRespBody) */ {
 public:
  ExitGroupNotifyRespBody();
  virtual ~ExitGroupNotifyRespBody();

  ExitGroupNotifyRespBody(const ExitGroupNotifyRespBody& from);

  inline ExitGroupNotifyRespBody& operator=(const ExitGroupNotifyRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ExitGroupNotifyRespBody& default_instance();

  static inline const ExitGroupNotifyRespBody* internal_default_instance() {
    return reinterpret_cast<const ExitGroupNotifyRespBody*>(
               &_ExitGroupNotifyRespBody_default_instance_);
  }

  void Swap(ExitGroupNotifyRespBody* other);

  // implements Message ----------------------------------------------

  inline ExitGroupNotifyRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  ExitGroupNotifyRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ExitGroupNotifyRespBody& from);
  void MergeFrom(const ExitGroupNotifyRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ExitGroupNotifyRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string group = 2;
  void clear_group();
  static const int kGroupFieldNumber = 2;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // .Client client = 1;
  bool has_client() const;
  void clear_client();
  static const int kClientFieldNumber = 1;
  const ::Client& client() const;
  ::Client* mutable_client();
  ::Client* release_client();
  void set_allocated_client(::Client* client);

  // @@protoc_insertion_point(class_scope:ExitGroupNotifyRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::Client* client_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChatReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ChatReqBody) */ {
 public:
  ChatReqBody();
  virtual ~ChatReqBody();

  ChatReqBody(const ChatReqBody& from);

  inline ChatReqBody& operator=(const ChatReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ChatReqBody& default_instance();

  static inline const ChatReqBody* internal_default_instance() {
    return reinterpret_cast<const ChatReqBody*>(
               &_ChatReqBody_default_instance_);
  }

  void Swap(ChatReqBody* other);

  // implements Message ----------------------------------------------

  inline ChatReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  ChatReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChatReqBody& from);
  void MergeFrom(const ChatReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChatReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string text = 3;
  void clear_text();
  static const int kTextFieldNumber = 3;
  const ::std::string& text() const;
  void set_text(const ::std::string& value);
  #if LANG_CXX11
  void set_text(::std::string&& value);
  #endif
  void set_text(const char* value);
  void set_text(const char* value, size_t size);
  ::std::string* mutable_text();
  ::std::string* release_text();
  void set_allocated_text(::std::string* text);

  // string group = 4;
  void clear_group();
  static const int kGroupFieldNumber = 4;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // string toId = 5;
  void clear_toid();
  static const int kToIdFieldNumber = 5;
  const ::std::string& toid() const;
  void set_toid(const ::std::string& value);
  #if LANG_CXX11
  void set_toid(::std::string&& value);
  #endif
  void set_toid(const char* value);
  void set_toid(const char* value, size_t size);
  ::std::string* mutable_toid();
  ::std::string* release_toid();
  void set_allocated_toid(::std::string* toid);

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // .ChatType type = 2;
  void clear_type();
  static const int kTypeFieldNumber = 2;
  ::ChatType type() const;
  void set_type(::ChatType value);

  // @@protoc_insertion_point(class_scope:ChatReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr text_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::google::protobuf::internal::ArenaStringPtr toid_;
  ::google::protobuf::int64 time_;
  int type_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChatRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ChatRespBody) */ {
 public:
  ChatRespBody();
  virtual ~ChatRespBody();

  ChatRespBody(const ChatRespBody& from);

  inline ChatRespBody& operator=(const ChatRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ChatRespBody& default_instance();

  static inline const ChatRespBody* internal_default_instance() {
    return reinterpret_cast<const ChatRespBody*>(
               &_ChatRespBody_default_instance_);
  }

  void Swap(ChatRespBody* other);

  // implements Message ----------------------------------------------

  inline ChatRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  ChatRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChatRespBody& from);
  void MergeFrom(const ChatRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChatRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string text = 3;
  void clear_text();
  static const int kTextFieldNumber = 3;
  const ::std::string& text() const;
  void set_text(const ::std::string& value);
  #if LANG_CXX11
  void set_text(::std::string&& value);
  #endif
  void set_text(const char* value);
  void set_text(const char* value, size_t size);
  ::std::string* mutable_text();
  ::std::string* release_text();
  void set_allocated_text(::std::string* text);

  // string group = 6;
  void clear_group();
  static const int kGroupFieldNumber = 6;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // string id = 7;
  void clear_id();
  static const int kIdFieldNumber = 7;
  const ::std::string& id() const;
  void set_id(const ::std::string& value);
  #if LANG_CXX11
  void set_id(::std::string&& value);
  #endif
  void set_id(const char* value);
  void set_id(const char* value, size_t size);
  ::std::string* mutable_id();
  ::std::string* release_id();
  void set_allocated_id(::std::string* id);

  // .Client fromClient = 4;
  bool has_fromclient() const;
  void clear_fromclient();
  static const int kFromClientFieldNumber = 4;
  const ::Client& fromclient() const;
  ::Client* mutable_fromclient();
  ::Client* release_fromclient();
  void set_allocated_fromclient(::Client* fromclient);

  // .Client toClient = 5;
  bool has_toclient() const;
  void clear_toclient();
  static const int kToClientFieldNumber = 5;
  const ::Client& toclient() const;
  ::Client* mutable_toclient();
  ::Client* release_toclient();
  void set_allocated_toclient(::Client* toclient);

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // .ChatType type = 2;
  void clear_type();
  static const int kTypeFieldNumber = 2;
  ::ChatType type() const;
  void set_type(::ChatType value);

  // @@protoc_insertion_point(class_scope:ChatRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr text_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::google::protobuf::internal::ArenaStringPtr id_;
  ::Client* fromclient_;
  ::Client* toclient_;
  ::google::protobuf::int64 time_;
  int type_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ClientPageReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ClientPageReqBody) */ {
 public:
  ClientPageReqBody();
  virtual ~ClientPageReqBody();

  ClientPageReqBody(const ClientPageReqBody& from);

  inline ClientPageReqBody& operator=(const ClientPageReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ClientPageReqBody& default_instance();

  static inline const ClientPageReqBody* internal_default_instance() {
    return reinterpret_cast<const ClientPageReqBody*>(
               &_ClientPageReqBody_default_instance_);
  }

  void Swap(ClientPageReqBody* other);

  // implements Message ----------------------------------------------

  inline ClientPageReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  ClientPageReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ClientPageReqBody& from);
  void MergeFrom(const ClientPageReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ClientPageReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string group = 3;
  void clear_group();
  static const int kGroupFieldNumber = 3;
  const ::std::string& group() const;
  void set_group(const ::std::string& value);
  #if LANG_CXX11
  void set_group(::std::string&& value);
  #endif
  void set_group(const char* value);
  void set_group(const char* value, size_t size);
  ::std::string* mutable_group();
  ::std::string* release_group();
  void set_allocated_group(::std::string* group);

  // int32 pageIndex = 1;
  void clear_pageindex();
  static const int kPageIndexFieldNumber = 1;
  ::google::protobuf::int32 pageindex() const;
  void set_pageindex(::google::protobuf::int32 value);

  // int32 pageSize = 2;
  void clear_pagesize();
  static const int kPageSizeFieldNumber = 2;
  ::google::protobuf::int32 pagesize() const;
  void set_pagesize(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:ClientPageReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr group_;
  ::google::protobuf::int32 pageindex_;
  ::google::protobuf::int32 pagesize_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ClientPageRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:ClientPageRespBody) */ {
 public:
  ClientPageRespBody();
  virtual ~ClientPageRespBody();

  ClientPageRespBody(const ClientPageRespBody& from);

  inline ClientPageRespBody& operator=(const ClientPageRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ClientPageRespBody& default_instance();

  static inline const ClientPageRespBody* internal_default_instance() {
    return reinterpret_cast<const ClientPageRespBody*>(
               &_ClientPageRespBody_default_instance_);
  }

  void Swap(ClientPageRespBody* other);

  // implements Message ----------------------------------------------

  inline ClientPageRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  ClientPageRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ClientPageRespBody& from);
  void MergeFrom(const ClientPageRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ClientPageRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .Client clients = 4;
  int clients_size() const;
  void clear_clients();
  static const int kClientsFieldNumber = 4;
  const ::Client& clients(int index) const;
  ::Client* mutable_clients(int index);
  ::Client* add_clients();
  ::google::protobuf::RepeatedPtrField< ::Client >*
      mutable_clients();
  const ::google::protobuf::RepeatedPtrField< ::Client >&
      clients() const;

  // int32 pageIndex = 1;
  void clear_pageindex();
  static const int kPageIndexFieldNumber = 1;
  ::google::protobuf::int32 pageindex() const;
  void set_pageindex(::google::protobuf::int32 value);

  // int32 pageSize = 2;
  void clear_pagesize();
  static const int kPageSizeFieldNumber = 2;
  ::google::protobuf::int32 pagesize() const;
  void set_pagesize(::google::protobuf::int32 value);

  // int32 recordCount = 3;
  void clear_recordcount();
  static const int kRecordCountFieldNumber = 3;
  ::google::protobuf::int32 recordcount() const;
  void set_recordcount(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:ClientPageRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::Client > clients_;
  ::google::protobuf::int32 pageindex_;
  ::google::protobuf::int32 pagesize_;
  ::google::protobuf::int32 recordcount_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BeginToLiveReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:BeginToLiveReqBody) */ {
 public:
  BeginToLiveReqBody();
  virtual ~BeginToLiveReqBody();

  BeginToLiveReqBody(const BeginToLiveReqBody& from);

  inline BeginToLiveReqBody& operator=(const BeginToLiveReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BeginToLiveReqBody& default_instance();

  static inline const BeginToLiveReqBody* internal_default_instance() {
    return reinterpret_cast<const BeginToLiveReqBody*>(
               &_BeginToLiveReqBody_default_instance_);
  }

  void Swap(BeginToLiveReqBody* other);

  // implements Message ----------------------------------------------

  inline BeginToLiveReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  BeginToLiveReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const BeginToLiveReqBody& from);
  void MergeFrom(const BeginToLiveReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(BeginToLiveReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:BeginToLiveReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 time_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BeginToLiveRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:BeginToLiveRespBody) */ {
 public:
  BeginToLiveRespBody();
  virtual ~BeginToLiveRespBody();

  BeginToLiveRespBody(const BeginToLiveRespBody& from);

  inline BeginToLiveRespBody& operator=(const BeginToLiveRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BeginToLiveRespBody& default_instance();

  static inline const BeginToLiveRespBody* internal_default_instance() {
    return reinterpret_cast<const BeginToLiveRespBody*>(
               &_BeginToLiveRespBody_default_instance_);
  }

  void Swap(BeginToLiveRespBody* other);

  // implements Message ----------------------------------------------

  inline BeginToLiveRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  BeginToLiveRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const BeginToLiveRespBody& from);
  void MergeFrom(const BeginToLiveRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(BeginToLiveRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string rtmppublishurl = 3;
  void clear_rtmppublishurl();
  static const int kRtmppublishurlFieldNumber = 3;
  const ::std::string& rtmppublishurl() const;
  void set_rtmppublishurl(const ::std::string& value);
  #if LANG_CXX11
  void set_rtmppublishurl(::std::string&& value);
  #endif
  void set_rtmppublishurl(const char* value);
  void set_rtmppublishurl(const char* value, size_t size);
  ::std::string* mutable_rtmppublishurl();
  ::std::string* release_rtmppublishurl();
  void set_allocated_rtmppublishurl(::std::string* rtmppublishurl);

  // string rtmpliveurl = 4;
  void clear_rtmpliveurl();
  static const int kRtmpliveurlFieldNumber = 4;
  const ::std::string& rtmpliveurl() const;
  void set_rtmpliveurl(const ::std::string& value);
  #if LANG_CXX11
  void set_rtmpliveurl(::std::string&& value);
  #endif
  void set_rtmpliveurl(const char* value);
  void set_rtmpliveurl(const char* value, size_t size);
  ::std::string* mutable_rtmpliveurl();
  ::std::string* release_rtmpliveurl();
  void set_allocated_rtmpliveurl(::std::string* rtmpliveurl);

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // int64 liveid = 2;
  void clear_liveid();
  static const int kLiveidFieldNumber = 2;
  ::google::protobuf::int64 liveid() const;
  void set_liveid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:BeginToLiveRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr rtmppublishurl_;
  ::google::protobuf::internal::ArenaStringPtr rtmpliveurl_;
  ::google::protobuf::int64 time_;
  ::google::protobuf::int64 liveid_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class EndLiveReqBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:EndLiveReqBody) */ {
 public:
  EndLiveReqBody();
  virtual ~EndLiveReqBody();

  EndLiveReqBody(const EndLiveReqBody& from);

  inline EndLiveReqBody& operator=(const EndLiveReqBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const EndLiveReqBody& default_instance();

  static inline const EndLiveReqBody* internal_default_instance() {
    return reinterpret_cast<const EndLiveReqBody*>(
               &_EndLiveReqBody_default_instance_);
  }

  void Swap(EndLiveReqBody* other);

  // implements Message ----------------------------------------------

  inline EndLiveReqBody* New() const PROTOBUF_FINAL { return New(NULL); }

  EndLiveReqBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const EndLiveReqBody& from);
  void MergeFrom(const EndLiveReqBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(EndLiveReqBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:EndLiveReqBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 time_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class EndLiveRespBody : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:EndLiveRespBody) */ {
 public:
  EndLiveRespBody();
  virtual ~EndLiveRespBody();

  EndLiveRespBody(const EndLiveRespBody& from);

  inline EndLiveRespBody& operator=(const EndLiveRespBody& from) {
    CopyFrom(from);
    return *this;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const EndLiveRespBody& default_instance();

  static inline const EndLiveRespBody* internal_default_instance() {
    return reinterpret_cast<const EndLiveRespBody*>(
               &_EndLiveRespBody_default_instance_);
  }

  void Swap(EndLiveRespBody* other);

  // implements Message ----------------------------------------------

  inline EndLiveRespBody* New() const PROTOBUF_FINAL { return New(NULL); }

  EndLiveRespBody* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const EndLiveRespBody& from);
  void MergeFrom(const EndLiveRespBody& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
      const PROTOBUF_FINAL {
    return InternalSerializeWithCachedSizesToArray(
        ::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
  }
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(EndLiveRespBody* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 time = 1;
  void clear_time();
  static const int kTimeFieldNumber = 1;
  ::google::protobuf::int64 time() const;
  void set_time(::google::protobuf::int64 value);

  // int64 liveid = 2;
  void clear_liveid();
  static const int kLiveidFieldNumber = 2;
  ::google::protobuf::int64 liveid() const;
  void set_liveid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:EndLiveRespBody)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 time_;
  ::google::protobuf::int64 liveid_;
  mutable int _cached_size_;
  friend struct  protobuf_chat_2eproto::TableStruct;
};
// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// User

// int64 id = 1;
inline void User::clear_id() {
  id_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 User::id() const {
  // @@protoc_insertion_point(field_get:User.id)
  return id_;
}
inline void User::set_id(::google::protobuf::int64 value) {
  
  id_ = value;
  // @@protoc_insertion_point(field_set:User.id)
}

// string nick = 2;
inline void User::clear_nick() {
  nick_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& User::nick() const {
  // @@protoc_insertion_point(field_get:User.nick)
  return nick_.GetNoArena();
}
inline void User::set_nick(const ::std::string& value) {
  
  nick_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:User.nick)
}
#if LANG_CXX11
inline void User::set_nick(::std::string&& value) {
  
  nick_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:User.nick)
}
#endif
inline void User::set_nick(const char* value) {
  
  nick_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:User.nick)
}
inline void User::set_nick(const char* value, size_t size) {
  
  nick_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:User.nick)
}
inline ::std::string* User::mutable_nick() {
  
  // @@protoc_insertion_point(field_mutable:User.nick)
  return nick_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* User::release_nick() {
  // @@protoc_insertion_point(field_release:User.nick)
  
  return nick_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void User::set_allocated_nick(::std::string* nick) {
  if (nick != NULL) {
    
  } else {
    
  }
  nick_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), nick);
  // @@protoc_insertion_point(field_set_allocated:User.nick)
}

// string avatar = 3;
inline void User::clear_avatar() {
  avatar_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& User::avatar() const {
  // @@protoc_insertion_point(field_get:User.avatar)
  return avatar_.GetNoArena();
}
inline void User::set_avatar(const ::std::string& value) {
  
  avatar_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:User.avatar)
}
#if LANG_CXX11
inline void User::set_avatar(::std::string&& value) {
  
  avatar_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:User.avatar)
}
#endif
inline void User::set_avatar(const char* value) {
  
  avatar_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:User.avatar)
}
inline void User::set_avatar(const char* value, size_t size) {
  
  avatar_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:User.avatar)
}
inline ::std::string* User::mutable_avatar() {
  
  // @@protoc_insertion_point(field_mutable:User.avatar)
  return avatar_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* User::release_avatar() {
  // @@protoc_insertion_point(field_release:User.avatar)
  
  return avatar_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void User::set_allocated_avatar(::std::string* avatar) {
  if (avatar != NULL) {
    
  } else {
    
  }
  avatar_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), avatar);
  // @@protoc_insertion_point(field_set_allocated:User.avatar)
}

// -------------------------------------------------------------------

// Client

// string id = 1;
inline void Client::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Client::id() const {
  // @@protoc_insertion_point(field_get:Client.id)
  return id_.GetNoArena();
}
inline void Client::set_id(const ::std::string& value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Client.id)
}
#if LANG_CXX11
inline void Client::set_id(::std::string&& value) {
  
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:Client.id)
}
#endif
inline void Client::set_id(const char* value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Client.id)
}
inline void Client::set_id(const char* value, size_t size) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Client.id)
}
inline ::std::string* Client::mutable_id() {
  
  // @@protoc_insertion_point(field_mutable:Client.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Client::release_id() {
  // @@protoc_insertion_point(field_release:Client.id)
  
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Client::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    
  } else {
    
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:Client.id)
}

// string ip = 2;
inline void Client::clear_ip() {
  ip_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Client::ip() const {
  // @@protoc_insertion_point(field_get:Client.ip)
  return ip_.GetNoArena();
}
inline void Client::set_ip(const ::std::string& value) {
  
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Client.ip)
}
#if LANG_CXX11
inline void Client::set_ip(::std::string&& value) {
  
  ip_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:Client.ip)
}
#endif
inline void Client::set_ip(const char* value) {
  
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Client.ip)
}
inline void Client::set_ip(const char* value, size_t size) {
  
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Client.ip)
}
inline ::std::string* Client::mutable_ip() {
  
  // @@protoc_insertion_point(field_mutable:Client.ip)
  return ip_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Client::release_ip() {
  // @@protoc_insertion_point(field_release:Client.ip)
  
  return ip_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Client::set_allocated_ip(::std::string* ip) {
  if (ip != NULL) {
    
  } else {
    
  }
  ip_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ip);
  // @@protoc_insertion_point(field_set_allocated:Client.ip)
}

// int32 port = 3;
inline void Client::clear_port() {
  port_ = 0;
}
inline ::google::protobuf::int32 Client::port() const {
  // @@protoc_insertion_point(field_get:Client.port)
  return port_;
}
inline void Client::set_port(::google::protobuf::int32 value) {
  
  port_ = value;
  // @@protoc_insertion_point(field_set:Client.port)
}

// .User user = 4;
inline bool Client::has_user() const {
  return this != internal_default_instance() && user_ != NULL;
}
inline void Client::clear_user() {
  if (GetArenaNoVirtual() == NULL && user_ != NULL) delete user_;
  user_ = NULL;
}
inline const ::User& Client::user() const {
  // @@protoc_insertion_point(field_get:Client.user)
  return user_ != NULL ? *user_
                         : *::User::internal_default_instance();
}
inline ::User* Client::mutable_user() {
  
  if (user_ == NULL) {
    user_ = new ::User;
  }
  // @@protoc_insertion_point(field_mutable:Client.user)
  return user_;
}
inline ::User* Client::release_user() {
  // @@protoc_insertion_point(field_release:Client.user)
  
  ::User* temp = user_;
  user_ = NULL;
  return temp;
}
inline void Client::set_allocated_user(::User* user) {
  delete user_;
  user_ = user;
  if (user) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:Client.user)
}

// string region = 5;
inline void Client::clear_region() {
  region_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Client::region() const {
  // @@protoc_insertion_point(field_get:Client.region)
  return region_.GetNoArena();
}
inline void Client::set_region(const ::std::string& value) {
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Client.region)
}
#if LANG_CXX11
inline void Client::set_region(::std::string&& value) {
  
  region_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:Client.region)
}
#endif
inline void Client::set_region(const char* value) {
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Client.region)
}
inline void Client::set_region(const char* value, size_t size) {
  
  region_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Client.region)
}
inline ::std::string* Client::mutable_region() {
  
  // @@protoc_insertion_point(field_mutable:Client.region)
  return region_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Client::release_region() {
  // @@protoc_insertion_point(field_release:Client.region)
  
  return region_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Client::set_allocated_region(::std::string* region) {
  if (region != NULL) {
    
  } else {
    
  }
  region_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), region);
  // @@protoc_insertion_point(field_set_allocated:Client.region)
}

// string useragent = 6;
inline void Client::clear_useragent() {
  useragent_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& Client::useragent() const {
  // @@protoc_insertion_point(field_get:Client.useragent)
  return useragent_.GetNoArena();
}
inline void Client::set_useragent(const ::std::string& value) {
  
  useragent_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Client.useragent)
}
#if LANG_CXX11
inline void Client::set_useragent(::std::string&& value) {
  
  useragent_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:Client.useragent)
}
#endif
inline void Client::set_useragent(const char* value) {
  
  useragent_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Client.useragent)
}
inline void Client::set_useragent(const char* value, size_t size) {
  
  useragent_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Client.useragent)
}
inline ::std::string* Client::mutable_useragent() {
  
  // @@protoc_insertion_point(field_mutable:Client.useragent)
  return useragent_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Client::release_useragent() {
  // @@protoc_insertion_point(field_release:Client.useragent)
  
  return useragent_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Client::set_allocated_useragent(::std::string* useragent) {
  if (useragent != NULL) {
    
  } else {
    
  }
  useragent_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), useragent);
  // @@protoc_insertion_point(field_set_allocated:Client.useragent)
}

// -------------------------------------------------------------------

// AuthReqBody

// string token = 1;
inline void AuthReqBody::clear_token() {
  token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::token() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.token)
  return token_.GetNoArena();
}
inline void AuthReqBody::set_token(const ::std::string& value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.token)
}
#if LANG_CXX11
inline void AuthReqBody::set_token(::std::string&& value) {
  
  token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.token)
}
#endif
inline void AuthReqBody::set_token(const char* value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.token)
}
inline void AuthReqBody::set_token(const char* value, size_t size) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.token)
}
inline ::std::string* AuthReqBody::mutable_token() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.token)
  return token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_token() {
  // @@protoc_insertion_point(field_release:AuthReqBody.token)
  
  return token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_token(::std::string* token) {
  if (token != NULL) {
    
  } else {
    
  }
  token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), token);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.token)
}

// string deviceId = 2;
inline void AuthReqBody::clear_deviceid() {
  deviceid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::deviceid() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.deviceId)
  return deviceid_.GetNoArena();
}
inline void AuthReqBody::set_deviceid(const ::std::string& value) {
  
  deviceid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.deviceId)
}
#if LANG_CXX11
inline void AuthReqBody::set_deviceid(::std::string&& value) {
  
  deviceid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.deviceId)
}
#endif
inline void AuthReqBody::set_deviceid(const char* value) {
  
  deviceid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.deviceId)
}
inline void AuthReqBody::set_deviceid(const char* value, size_t size) {
  
  deviceid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.deviceId)
}
inline ::std::string* AuthReqBody::mutable_deviceid() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.deviceId)
  return deviceid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_deviceid() {
  // @@protoc_insertion_point(field_release:AuthReqBody.deviceId)
  
  return deviceid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_deviceid(::std::string* deviceid) {
  if (deviceid != NULL) {
    
  } else {
    
  }
  deviceid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), deviceid);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.deviceId)
}

// int64 seq = 3;
inline void AuthReqBody::clear_seq() {
  seq_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 AuthReqBody::seq() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.seq)
  return seq_;
}
inline void AuthReqBody::set_seq(::google::protobuf::int64 value) {
  
  seq_ = value;
  // @@protoc_insertion_point(field_set:AuthReqBody.seq)
}

// .DeviceType deviceType = 4;
inline void AuthReqBody::clear_devicetype() {
  devicetype_ = 0;
}
inline ::DeviceType AuthReqBody::devicetype() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.deviceType)
  return static_cast< ::DeviceType >(devicetype_);
}
inline void AuthReqBody::set_devicetype(::DeviceType value) {
  
  devicetype_ = value;
  // @@protoc_insertion_point(field_set:AuthReqBody.deviceType)
}

// string cid = 5;
inline void AuthReqBody::clear_cid() {
  cid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::cid() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.cid)
  return cid_.GetNoArena();
}
inline void AuthReqBody::set_cid(const ::std::string& value) {
  
  cid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.cid)
}
#if LANG_CXX11
inline void AuthReqBody::set_cid(::std::string&& value) {
  
  cid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.cid)
}
#endif
inline void AuthReqBody::set_cid(const char* value) {
  
  cid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.cid)
}
inline void AuthReqBody::set_cid(const char* value, size_t size) {
  
  cid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.cid)
}
inline ::std::string* AuthReqBody::mutable_cid() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.cid)
  return cid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_cid() {
  // @@protoc_insertion_point(field_release:AuthReqBody.cid)
  
  return cid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_cid(::std::string* cid) {
  if (cid != NULL) {
    
  } else {
    
  }
  cid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cid);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.cid)
}

// string appVersion = 6;
inline void AuthReqBody::clear_appversion() {
  appversion_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::appversion() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.appVersion)
  return appversion_.GetNoArena();
}
inline void AuthReqBody::set_appversion(const ::std::string& value) {
  
  appversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.appVersion)
}
#if LANG_CXX11
inline void AuthReqBody::set_appversion(::std::string&& value) {
  
  appversion_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.appVersion)
}
#endif
inline void AuthReqBody::set_appversion(const char* value) {
  
  appversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.appVersion)
}
inline void AuthReqBody::set_appversion(const char* value, size_t size) {
  
  appversion_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.appVersion)
}
inline ::std::string* AuthReqBody::mutable_appversion() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.appVersion)
  return appversion_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_appversion() {
  // @@protoc_insertion_point(field_release:AuthReqBody.appVersion)
  
  return appversion_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_appversion(::std::string* appversion) {
  if (appversion != NULL) {
    
  } else {
    
  }
  appversion_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), appversion);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.appVersion)
}

// string deviceInfo = 7;
inline void AuthReqBody::clear_deviceinfo() {
  deviceinfo_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::deviceinfo() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.deviceInfo)
  return deviceinfo_.GetNoArena();
}
inline void AuthReqBody::set_deviceinfo(const ::std::string& value) {
  
  deviceinfo_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.deviceInfo)
}
#if LANG_CXX11
inline void AuthReqBody::set_deviceinfo(::std::string&& value) {
  
  deviceinfo_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.deviceInfo)
}
#endif
inline void AuthReqBody::set_deviceinfo(const char* value) {
  
  deviceinfo_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.deviceInfo)
}
inline void AuthReqBody::set_deviceinfo(const char* value, size_t size) {
  
  deviceinfo_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.deviceInfo)
}
inline ::std::string* AuthReqBody::mutable_deviceinfo() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.deviceInfo)
  return deviceinfo_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_deviceinfo() {
  // @@protoc_insertion_point(field_release:AuthReqBody.deviceInfo)
  
  return deviceinfo_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_deviceinfo(::std::string* deviceinfo) {
  if (deviceinfo != NULL) {
    
  } else {
    
  }
  deviceinfo_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), deviceinfo);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.deviceInfo)
}

// string sign = 8;
inline void AuthReqBody::clear_sign() {
  sign_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& AuthReqBody::sign() const {
  // @@protoc_insertion_point(field_get:AuthReqBody.sign)
  return sign_.GetNoArena();
}
inline void AuthReqBody::set_sign(const ::std::string& value) {
  
  sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:AuthReqBody.sign)
}
#if LANG_CXX11
inline void AuthReqBody::set_sign(::std::string&& value) {
  
  sign_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:AuthReqBody.sign)
}
#endif
inline void AuthReqBody::set_sign(const char* value) {
  
  sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:AuthReqBody.sign)
}
inline void AuthReqBody::set_sign(const char* value, size_t size) {
  
  sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:AuthReqBody.sign)
}
inline ::std::string* AuthReqBody::mutable_sign() {
  
  // @@protoc_insertion_point(field_mutable:AuthReqBody.sign)
  return sign_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AuthReqBody::release_sign() {
  // @@protoc_insertion_point(field_release:AuthReqBody.sign)
  
  return sign_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AuthReqBody::set_allocated_sign(::std::string* sign) {
  if (sign != NULL) {
    
  } else {
    
  }
  sign_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sign);
  // @@protoc_insertion_point(field_set_allocated:AuthReqBody.sign)
}

// -------------------------------------------------------------------

// AuthRespBody

// -------------------------------------------------------------------

// LoginReqBody

// string loginname = 1;
inline void LoginReqBody::clear_loginname() {
  loginname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LoginReqBody::loginname() const {
  // @@protoc_insertion_point(field_get:LoginReqBody.loginname)
  return loginname_.GetNoArena();
}
inline void LoginReqBody::set_loginname(const ::std::string& value) {
  
  loginname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LoginReqBody.loginname)
}
#if LANG_CXX11
inline void LoginReqBody::set_loginname(::std::string&& value) {
  
  loginname_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LoginReqBody.loginname)
}
#endif
inline void LoginReqBody::set_loginname(const char* value) {
  
  loginname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LoginReqBody.loginname)
}
inline void LoginReqBody::set_loginname(const char* value, size_t size) {
  
  loginname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LoginReqBody.loginname)
}
inline ::std::string* LoginReqBody::mutable_loginname() {
  
  // @@protoc_insertion_point(field_mutable:LoginReqBody.loginname)
  return loginname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LoginReqBody::release_loginname() {
  // @@protoc_insertion_point(field_release:LoginReqBody.loginname)
  
  return loginname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LoginReqBody::set_allocated_loginname(::std::string* loginname) {
  if (loginname != NULL) {
    
  } else {
    
  }
  loginname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), loginname);
  // @@protoc_insertion_point(field_set_allocated:LoginReqBody.loginname)
}

// string password = 2;
inline void LoginReqBody::clear_password() {
  password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LoginReqBody::password() const {
  // @@protoc_insertion_point(field_get:LoginReqBody.password)
  return password_.GetNoArena();
}
inline void LoginReqBody::set_password(const ::std::string& value) {
  
  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LoginReqBody.password)
}
#if LANG_CXX11
inline void LoginReqBody::set_password(::std::string&& value) {
  
  password_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LoginReqBody.password)
}
#endif
inline void LoginReqBody::set_password(const char* value) {
  
  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LoginReqBody.password)
}
inline void LoginReqBody::set_password(const char* value, size_t size) {
  
  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LoginReqBody.password)
}
inline ::std::string* LoginReqBody::mutable_password() {
  
  // @@protoc_insertion_point(field_mutable:LoginReqBody.password)
  return password_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LoginReqBody::release_password() {
  // @@protoc_insertion_point(field_release:LoginReqBody.password)
  
  return password_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LoginReqBody::set_allocated_password(::std::string* password) {
  if (password != NULL) {
    
  } else {
    
  }
  password_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), password);
  // @@protoc_insertion_point(field_set_allocated:LoginReqBody.password)
}

// string token = 3;
inline void LoginReqBody::clear_token() {
  token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LoginReqBody::token() const {
  // @@protoc_insertion_point(field_get:LoginReqBody.token)
  return token_.GetNoArena();
}
inline void LoginReqBody::set_token(const ::std::string& value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LoginReqBody.token)
}
#if LANG_CXX11
inline void LoginReqBody::set_token(::std::string&& value) {
  
  token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LoginReqBody.token)
}
#endif
inline void LoginReqBody::set_token(const char* value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LoginReqBody.token)
}
inline void LoginReqBody::set_token(const char* value, size_t size) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LoginReqBody.token)
}
inline ::std::string* LoginReqBody::mutable_token() {
  
  // @@protoc_insertion_point(field_mutable:LoginReqBody.token)
  return token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LoginReqBody::release_token() {
  // @@protoc_insertion_point(field_release:LoginReqBody.token)
  
  return token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LoginReqBody::set_allocated_token(::std::string* token) {
  if (token != NULL) {
    
  } else {
    
  }
  token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), token);
  // @@protoc_insertion_point(field_set_allocated:LoginReqBody.token)
}

// -------------------------------------------------------------------

// LoginRespBody

// string token = 1;
inline void LoginRespBody::clear_token() {
  token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& LoginRespBody::token() const {
  // @@protoc_insertion_point(field_get:LoginRespBody.token)
  return token_.GetNoArena();
}
inline void LoginRespBody::set_token(const ::std::string& value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:LoginRespBody.token)
}
#if LANG_CXX11
inline void LoginRespBody::set_token(::std::string&& value) {
  
  token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:LoginRespBody.token)
}
#endif
inline void LoginRespBody::set_token(const char* value) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:LoginRespBody.token)
}
inline void LoginRespBody::set_token(const char* value, size_t size) {
  
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:LoginRespBody.token)
}
inline ::std::string* LoginRespBody::mutable_token() {
  
  // @@protoc_insertion_point(field_mutable:LoginRespBody.token)
  return token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LoginRespBody::release_token() {
  // @@protoc_insertion_point(field_release:LoginRespBody.token)
  
  return token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LoginRespBody::set_allocated_token(::std::string* token) {
  if (token != NULL) {
    
  } else {
    
  }
  token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), token);
  // @@protoc_insertion_point(field_set_allocated:LoginRespBody.token)
}

// .User user = 2;
inline bool LoginRespBody::has_user() const {
  return this != internal_default_instance() && user_ != NULL;
}
inline void LoginRespBody::clear_user() {
  if (GetArenaNoVirtual() == NULL && user_ != NULL) delete user_;
  user_ = NULL;
}
inline const ::User& LoginRespBody::user() const {
  // @@protoc_insertion_point(field_get:LoginRespBody.user)
  return user_ != NULL ? *user_
                         : *::User::internal_default_instance();
}
inline ::User* LoginRespBody::mutable_user() {
  
  if (user_ == NULL) {
    user_ = new ::User;
  }
  // @@protoc_insertion_point(field_mutable:LoginRespBody.user)
  return user_;
}
inline ::User* LoginRespBody::release_user() {
  // @@protoc_insertion_point(field_release:LoginRespBody.user)
  
  ::User* temp = user_;
  user_ = NULL;
  return temp;
}
inline void LoginRespBody::set_allocated_user(::User* user) {
  delete user_;
  user_ = user;
  if (user) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:LoginRespBody.user)
}

// -------------------------------------------------------------------

// JoinGroupReqBody

// string group = 1;
inline void JoinGroupReqBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& JoinGroupReqBody::group() const {
  // @@protoc_insertion_point(field_get:JoinGroupReqBody.group)
  return group_.GetNoArena();
}
inline void JoinGroupReqBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JoinGroupReqBody.group)
}
#if LANG_CXX11
inline void JoinGroupReqBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JoinGroupReqBody.group)
}
#endif
inline void JoinGroupReqBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JoinGroupReqBody.group)
}
inline void JoinGroupReqBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JoinGroupReqBody.group)
}
inline ::std::string* JoinGroupReqBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:JoinGroupReqBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* JoinGroupReqBody::release_group() {
  // @@protoc_insertion_point(field_release:JoinGroupReqBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void JoinGroupReqBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:JoinGroupReqBody.group)
}

// -------------------------------------------------------------------

// JoinGroupRespBody

// .JoinGroupResult result = 1;
inline void JoinGroupRespBody::clear_result() {
  result_ = 0;
}
inline ::JoinGroupResult JoinGroupRespBody::result() const {
  // @@protoc_insertion_point(field_get:JoinGroupRespBody.result)
  return static_cast< ::JoinGroupResult >(result_);
}
inline void JoinGroupRespBody::set_result(::JoinGroupResult value) {
  
  result_ = value;
  // @@protoc_insertion_point(field_set:JoinGroupRespBody.result)
}

// string group = 2;
inline void JoinGroupRespBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& JoinGroupRespBody::group() const {
  // @@protoc_insertion_point(field_get:JoinGroupRespBody.group)
  return group_.GetNoArena();
}
inline void JoinGroupRespBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JoinGroupRespBody.group)
}
#if LANG_CXX11
inline void JoinGroupRespBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JoinGroupRespBody.group)
}
#endif
inline void JoinGroupRespBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JoinGroupRespBody.group)
}
inline void JoinGroupRespBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JoinGroupRespBody.group)
}
inline ::std::string* JoinGroupRespBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:JoinGroupRespBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* JoinGroupRespBody::release_group() {
  // @@protoc_insertion_point(field_release:JoinGroupRespBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void JoinGroupRespBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:JoinGroupRespBody.group)
}

// -------------------------------------------------------------------

// JoinGroupNotifyRespBody

// .Client client = 1;
inline bool JoinGroupNotifyRespBody::has_client() const {
  return this != internal_default_instance() && client_ != NULL;
}
inline void JoinGroupNotifyRespBody::clear_client() {
  if (GetArenaNoVirtual() == NULL && client_ != NULL) delete client_;
  client_ = NULL;
}
inline const ::Client& JoinGroupNotifyRespBody::client() const {
  // @@protoc_insertion_point(field_get:JoinGroupNotifyRespBody.client)
  return client_ != NULL ? *client_
                         : *::Client::internal_default_instance();
}
inline ::Client* JoinGroupNotifyRespBody::mutable_client() {
  
  if (client_ == NULL) {
    client_ = new ::Client;
  }
  // @@protoc_insertion_point(field_mutable:JoinGroupNotifyRespBody.client)
  return client_;
}
inline ::Client* JoinGroupNotifyRespBody::release_client() {
  // @@protoc_insertion_point(field_release:JoinGroupNotifyRespBody.client)
  
  ::Client* temp = client_;
  client_ = NULL;
  return temp;
}
inline void JoinGroupNotifyRespBody::set_allocated_client(::Client* client) {
  delete client_;
  client_ = client;
  if (client) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:JoinGroupNotifyRespBody.client)
}

// string group = 2;
inline void JoinGroupNotifyRespBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& JoinGroupNotifyRespBody::group() const {
  // @@protoc_insertion_point(field_get:JoinGroupNotifyRespBody.group)
  return group_.GetNoArena();
}
inline void JoinGroupNotifyRespBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:JoinGroupNotifyRespBody.group)
}
#if LANG_CXX11
inline void JoinGroupNotifyRespBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:JoinGroupNotifyRespBody.group)
}
#endif
inline void JoinGroupNotifyRespBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:JoinGroupNotifyRespBody.group)
}
inline void JoinGroupNotifyRespBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:JoinGroupNotifyRespBody.group)
}
inline ::std::string* JoinGroupNotifyRespBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:JoinGroupNotifyRespBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* JoinGroupNotifyRespBody::release_group() {
  // @@protoc_insertion_point(field_release:JoinGroupNotifyRespBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void JoinGroupNotifyRespBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:JoinGroupNotifyRespBody.group)
}

// -------------------------------------------------------------------

// ExitGroupNotifyRespBody

// .Client client = 1;
inline bool ExitGroupNotifyRespBody::has_client() const {
  return this != internal_default_instance() && client_ != NULL;
}
inline void ExitGroupNotifyRespBody::clear_client() {
  if (GetArenaNoVirtual() == NULL && client_ != NULL) delete client_;
  client_ = NULL;
}
inline const ::Client& ExitGroupNotifyRespBody::client() const {
  // @@protoc_insertion_point(field_get:ExitGroupNotifyRespBody.client)
  return client_ != NULL ? *client_
                         : *::Client::internal_default_instance();
}
inline ::Client* ExitGroupNotifyRespBody::mutable_client() {
  
  if (client_ == NULL) {
    client_ = new ::Client;
  }
  // @@protoc_insertion_point(field_mutable:ExitGroupNotifyRespBody.client)
  return client_;
}
inline ::Client* ExitGroupNotifyRespBody::release_client() {
  // @@protoc_insertion_point(field_release:ExitGroupNotifyRespBody.client)
  
  ::Client* temp = client_;
  client_ = NULL;
  return temp;
}
inline void ExitGroupNotifyRespBody::set_allocated_client(::Client* client) {
  delete client_;
  client_ = client;
  if (client) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:ExitGroupNotifyRespBody.client)
}

// string group = 2;
inline void ExitGroupNotifyRespBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ExitGroupNotifyRespBody::group() const {
  // @@protoc_insertion_point(field_get:ExitGroupNotifyRespBody.group)
  return group_.GetNoArena();
}
inline void ExitGroupNotifyRespBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ExitGroupNotifyRespBody.group)
}
#if LANG_CXX11
inline void ExitGroupNotifyRespBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ExitGroupNotifyRespBody.group)
}
#endif
inline void ExitGroupNotifyRespBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ExitGroupNotifyRespBody.group)
}
inline void ExitGroupNotifyRespBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ExitGroupNotifyRespBody.group)
}
inline ::std::string* ExitGroupNotifyRespBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:ExitGroupNotifyRespBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ExitGroupNotifyRespBody::release_group() {
  // @@protoc_insertion_point(field_release:ExitGroupNotifyRespBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ExitGroupNotifyRespBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:ExitGroupNotifyRespBody.group)
}

// -------------------------------------------------------------------

// ChatReqBody

// int64 time = 1;
inline void ChatReqBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChatReqBody::time() const {
  // @@protoc_insertion_point(field_get:ChatReqBody.time)
  return time_;
}
inline void ChatReqBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:ChatReqBody.time)
}

// .ChatType type = 2;
inline void ChatReqBody::clear_type() {
  type_ = 0;
}
inline ::ChatType ChatReqBody::type() const {
  // @@protoc_insertion_point(field_get:ChatReqBody.type)
  return static_cast< ::ChatType >(type_);
}
inline void ChatReqBody::set_type(::ChatType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:ChatReqBody.type)
}

// string text = 3;
inline void ChatReqBody::clear_text() {
  text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatReqBody::text() const {
  // @@protoc_insertion_point(field_get:ChatReqBody.text)
  return text_.GetNoArena();
}
inline void ChatReqBody::set_text(const ::std::string& value) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatReqBody.text)
}
#if LANG_CXX11
inline void ChatReqBody::set_text(::std::string&& value) {
  
  text_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatReqBody.text)
}
#endif
inline void ChatReqBody::set_text(const char* value) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatReqBody.text)
}
inline void ChatReqBody::set_text(const char* value, size_t size) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatReqBody.text)
}
inline ::std::string* ChatReqBody::mutable_text() {
  
  // @@protoc_insertion_point(field_mutable:ChatReqBody.text)
  return text_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatReqBody::release_text() {
  // @@protoc_insertion_point(field_release:ChatReqBody.text)
  
  return text_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatReqBody::set_allocated_text(::std::string* text) {
  if (text != NULL) {
    
  } else {
    
  }
  text_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), text);
  // @@protoc_insertion_point(field_set_allocated:ChatReqBody.text)
}

// string group = 4;
inline void ChatReqBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatReqBody::group() const {
  // @@protoc_insertion_point(field_get:ChatReqBody.group)
  return group_.GetNoArena();
}
inline void ChatReqBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatReqBody.group)
}
#if LANG_CXX11
inline void ChatReqBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatReqBody.group)
}
#endif
inline void ChatReqBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatReqBody.group)
}
inline void ChatReqBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatReqBody.group)
}
inline ::std::string* ChatReqBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:ChatReqBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatReqBody::release_group() {
  // @@protoc_insertion_point(field_release:ChatReqBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatReqBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:ChatReqBody.group)
}

// string toId = 5;
inline void ChatReqBody::clear_toid() {
  toid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatReqBody::toid() const {
  // @@protoc_insertion_point(field_get:ChatReqBody.toId)
  return toid_.GetNoArena();
}
inline void ChatReqBody::set_toid(const ::std::string& value) {
  
  toid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatReqBody.toId)
}
#if LANG_CXX11
inline void ChatReqBody::set_toid(::std::string&& value) {
  
  toid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatReqBody.toId)
}
#endif
inline void ChatReqBody::set_toid(const char* value) {
  
  toid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatReqBody.toId)
}
inline void ChatReqBody::set_toid(const char* value, size_t size) {
  
  toid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatReqBody.toId)
}
inline ::std::string* ChatReqBody::mutable_toid() {
  
  // @@protoc_insertion_point(field_mutable:ChatReqBody.toId)
  return toid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatReqBody::release_toid() {
  // @@protoc_insertion_point(field_release:ChatReqBody.toId)
  
  return toid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatReqBody::set_allocated_toid(::std::string* toid) {
  if (toid != NULL) {
    
  } else {
    
  }
  toid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), toid);
  // @@protoc_insertion_point(field_set_allocated:ChatReqBody.toId)
}

// -------------------------------------------------------------------

// ChatRespBody

// int64 time = 1;
inline void ChatRespBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChatRespBody::time() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.time)
  return time_;
}
inline void ChatRespBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:ChatRespBody.time)
}

// .ChatType type = 2;
inline void ChatRespBody::clear_type() {
  type_ = 0;
}
inline ::ChatType ChatRespBody::type() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.type)
  return static_cast< ::ChatType >(type_);
}
inline void ChatRespBody::set_type(::ChatType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:ChatRespBody.type)
}

// string text = 3;
inline void ChatRespBody::clear_text() {
  text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatRespBody::text() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.text)
  return text_.GetNoArena();
}
inline void ChatRespBody::set_text(const ::std::string& value) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatRespBody.text)
}
#if LANG_CXX11
inline void ChatRespBody::set_text(::std::string&& value) {
  
  text_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatRespBody.text)
}
#endif
inline void ChatRespBody::set_text(const char* value) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatRespBody.text)
}
inline void ChatRespBody::set_text(const char* value, size_t size) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatRespBody.text)
}
inline ::std::string* ChatRespBody::mutable_text() {
  
  // @@protoc_insertion_point(field_mutable:ChatRespBody.text)
  return text_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatRespBody::release_text() {
  // @@protoc_insertion_point(field_release:ChatRespBody.text)
  
  return text_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatRespBody::set_allocated_text(::std::string* text) {
  if (text != NULL) {
    
  } else {
    
  }
  text_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), text);
  // @@protoc_insertion_point(field_set_allocated:ChatRespBody.text)
}

// .Client fromClient = 4;
inline bool ChatRespBody::has_fromclient() const {
  return this != internal_default_instance() && fromclient_ != NULL;
}
inline void ChatRespBody::clear_fromclient() {
  if (GetArenaNoVirtual() == NULL && fromclient_ != NULL) delete fromclient_;
  fromclient_ = NULL;
}
inline const ::Client& ChatRespBody::fromclient() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.fromClient)
  return fromclient_ != NULL ? *fromclient_
                         : *::Client::internal_default_instance();
}
inline ::Client* ChatRespBody::mutable_fromclient() {
  
  if (fromclient_ == NULL) {
    fromclient_ = new ::Client;
  }
  // @@protoc_insertion_point(field_mutable:ChatRespBody.fromClient)
  return fromclient_;
}
inline ::Client* ChatRespBody::release_fromclient() {
  // @@protoc_insertion_point(field_release:ChatRespBody.fromClient)
  
  ::Client* temp = fromclient_;
  fromclient_ = NULL;
  return temp;
}
inline void ChatRespBody::set_allocated_fromclient(::Client* fromclient) {
  delete fromclient_;
  fromclient_ = fromclient;
  if (fromclient) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:ChatRespBody.fromClient)
}

// .Client toClient = 5;
inline bool ChatRespBody::has_toclient() const {
  return this != internal_default_instance() && toclient_ != NULL;
}
inline void ChatRespBody::clear_toclient() {
  if (GetArenaNoVirtual() == NULL && toclient_ != NULL) delete toclient_;
  toclient_ = NULL;
}
inline const ::Client& ChatRespBody::toclient() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.toClient)
  return toclient_ != NULL ? *toclient_
                         : *::Client::internal_default_instance();
}
inline ::Client* ChatRespBody::mutable_toclient() {
  
  if (toclient_ == NULL) {
    toclient_ = new ::Client;
  }
  // @@protoc_insertion_point(field_mutable:ChatRespBody.toClient)
  return toclient_;
}
inline ::Client* ChatRespBody::release_toclient() {
  // @@protoc_insertion_point(field_release:ChatRespBody.toClient)
  
  ::Client* temp = toclient_;
  toclient_ = NULL;
  return temp;
}
inline void ChatRespBody::set_allocated_toclient(::Client* toclient) {
  delete toclient_;
  toclient_ = toclient;
  if (toclient) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:ChatRespBody.toClient)
}

// string group = 6;
inline void ChatRespBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatRespBody::group() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.group)
  return group_.GetNoArena();
}
inline void ChatRespBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatRespBody.group)
}
#if LANG_CXX11
inline void ChatRespBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatRespBody.group)
}
#endif
inline void ChatRespBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatRespBody.group)
}
inline void ChatRespBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatRespBody.group)
}
inline ::std::string* ChatRespBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:ChatRespBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatRespBody::release_group() {
  // @@protoc_insertion_point(field_release:ChatRespBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatRespBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:ChatRespBody.group)
}

// string id = 7;
inline void ChatRespBody::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatRespBody::id() const {
  // @@protoc_insertion_point(field_get:ChatRespBody.id)
  return id_.GetNoArena();
}
inline void ChatRespBody::set_id(const ::std::string& value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ChatRespBody.id)
}
#if LANG_CXX11
inline void ChatRespBody::set_id(::std::string&& value) {
  
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ChatRespBody.id)
}
#endif
inline void ChatRespBody::set_id(const char* value) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ChatRespBody.id)
}
inline void ChatRespBody::set_id(const char* value, size_t size) {
  
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ChatRespBody.id)
}
inline ::std::string* ChatRespBody::mutable_id() {
  
  // @@protoc_insertion_point(field_mutable:ChatRespBody.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatRespBody::release_id() {
  // @@protoc_insertion_point(field_release:ChatRespBody.id)
  
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatRespBody::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    
  } else {
    
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:ChatRespBody.id)
}

// -------------------------------------------------------------------

// ClientPageReqBody

// int32 pageIndex = 1;
inline void ClientPageReqBody::clear_pageindex() {
  pageindex_ = 0;
}
inline ::google::protobuf::int32 ClientPageReqBody::pageindex() const {
  // @@protoc_insertion_point(field_get:ClientPageReqBody.pageIndex)
  return pageindex_;
}
inline void ClientPageReqBody::set_pageindex(::google::protobuf::int32 value) {
  
  pageindex_ = value;
  // @@protoc_insertion_point(field_set:ClientPageReqBody.pageIndex)
}

// int32 pageSize = 2;
inline void ClientPageReqBody::clear_pagesize() {
  pagesize_ = 0;
}
inline ::google::protobuf::int32 ClientPageReqBody::pagesize() const {
  // @@protoc_insertion_point(field_get:ClientPageReqBody.pageSize)
  return pagesize_;
}
inline void ClientPageReqBody::set_pagesize(::google::protobuf::int32 value) {
  
  pagesize_ = value;
  // @@protoc_insertion_point(field_set:ClientPageReqBody.pageSize)
}

// string group = 3;
inline void ClientPageReqBody::clear_group() {
  group_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ClientPageReqBody::group() const {
  // @@protoc_insertion_point(field_get:ClientPageReqBody.group)
  return group_.GetNoArena();
}
inline void ClientPageReqBody::set_group(const ::std::string& value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:ClientPageReqBody.group)
}
#if LANG_CXX11
inline void ClientPageReqBody::set_group(::std::string&& value) {
  
  group_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:ClientPageReqBody.group)
}
#endif
inline void ClientPageReqBody::set_group(const char* value) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:ClientPageReqBody.group)
}
inline void ClientPageReqBody::set_group(const char* value, size_t size) {
  
  group_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:ClientPageReqBody.group)
}
inline ::std::string* ClientPageReqBody::mutable_group() {
  
  // @@protoc_insertion_point(field_mutable:ClientPageReqBody.group)
  return group_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ClientPageReqBody::release_group() {
  // @@protoc_insertion_point(field_release:ClientPageReqBody.group)
  
  return group_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ClientPageReqBody::set_allocated_group(::std::string* group) {
  if (group != NULL) {
    
  } else {
    
  }
  group_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), group);
  // @@protoc_insertion_point(field_set_allocated:ClientPageReqBody.group)
}

// -------------------------------------------------------------------

// ClientPageRespBody

// int32 pageIndex = 1;
inline void ClientPageRespBody::clear_pageindex() {
  pageindex_ = 0;
}
inline ::google::protobuf::int32 ClientPageRespBody::pageindex() const {
  // @@protoc_insertion_point(field_get:ClientPageRespBody.pageIndex)
  return pageindex_;
}
inline void ClientPageRespBody::set_pageindex(::google::protobuf::int32 value) {
  
  pageindex_ = value;
  // @@protoc_insertion_point(field_set:ClientPageRespBody.pageIndex)
}

// int32 pageSize = 2;
inline void ClientPageRespBody::clear_pagesize() {
  pagesize_ = 0;
}
inline ::google::protobuf::int32 ClientPageRespBody::pagesize() const {
  // @@protoc_insertion_point(field_get:ClientPageRespBody.pageSize)
  return pagesize_;
}
inline void ClientPageRespBody::set_pagesize(::google::protobuf::int32 value) {
  
  pagesize_ = value;
  // @@protoc_insertion_point(field_set:ClientPageRespBody.pageSize)
}

// int32 recordCount = 3;
inline void ClientPageRespBody::clear_recordcount() {
  recordcount_ = 0;
}
inline ::google::protobuf::int32 ClientPageRespBody::recordcount() const {
  // @@protoc_insertion_point(field_get:ClientPageRespBody.recordCount)
  return recordcount_;
}
inline void ClientPageRespBody::set_recordcount(::google::protobuf::int32 value) {
  
  recordcount_ = value;
  // @@protoc_insertion_point(field_set:ClientPageRespBody.recordCount)
}

// repeated .Client clients = 4;
inline int ClientPageRespBody::clients_size() const {
  return clients_.size();
}
inline void ClientPageRespBody::clear_clients() {
  clients_.Clear();
}
inline const ::Client& ClientPageRespBody::clients(int index) const {
  // @@protoc_insertion_point(field_get:ClientPageRespBody.clients)
  return clients_.Get(index);
}
inline ::Client* ClientPageRespBody::mutable_clients(int index) {
  // @@protoc_insertion_point(field_mutable:ClientPageRespBody.clients)
  return clients_.Mutable(index);
}
inline ::Client* ClientPageRespBody::add_clients() {
  // @@protoc_insertion_point(field_add:ClientPageRespBody.clients)
  return clients_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::Client >*
ClientPageRespBody::mutable_clients() {
  // @@protoc_insertion_point(field_mutable_list:ClientPageRespBody.clients)
  return &clients_;
}
inline const ::google::protobuf::RepeatedPtrField< ::Client >&
ClientPageRespBody::clients() const {
  // @@protoc_insertion_point(field_list:ClientPageRespBody.clients)
  return clients_;
}

// -------------------------------------------------------------------

// BeginToLiveReqBody

// int64 time = 1;
inline void BeginToLiveReqBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 BeginToLiveReqBody::time() const {
  // @@protoc_insertion_point(field_get:BeginToLiveReqBody.time)
  return time_;
}
inline void BeginToLiveReqBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:BeginToLiveReqBody.time)
}

// -------------------------------------------------------------------

// BeginToLiveRespBody

// int64 time = 1;
inline void BeginToLiveRespBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 BeginToLiveRespBody::time() const {
  // @@protoc_insertion_point(field_get:BeginToLiveRespBody.time)
  return time_;
}
inline void BeginToLiveRespBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:BeginToLiveRespBody.time)
}

// int64 liveid = 2;
inline void BeginToLiveRespBody::clear_liveid() {
  liveid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 BeginToLiveRespBody::liveid() const {
  // @@protoc_insertion_point(field_get:BeginToLiveRespBody.liveid)
  return liveid_;
}
inline void BeginToLiveRespBody::set_liveid(::google::protobuf::int64 value) {
  
  liveid_ = value;
  // @@protoc_insertion_point(field_set:BeginToLiveRespBody.liveid)
}

// string rtmppublishurl = 3;
inline void BeginToLiveRespBody::clear_rtmppublishurl() {
  rtmppublishurl_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& BeginToLiveRespBody::rtmppublishurl() const {
  // @@protoc_insertion_point(field_get:BeginToLiveRespBody.rtmppublishurl)
  return rtmppublishurl_.GetNoArena();
}
inline void BeginToLiveRespBody::set_rtmppublishurl(const ::std::string& value) {
  
  rtmppublishurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:BeginToLiveRespBody.rtmppublishurl)
}
#if LANG_CXX11
inline void BeginToLiveRespBody::set_rtmppublishurl(::std::string&& value) {
  
  rtmppublishurl_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:BeginToLiveRespBody.rtmppublishurl)
}
#endif
inline void BeginToLiveRespBody::set_rtmppublishurl(const char* value) {
  
  rtmppublishurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:BeginToLiveRespBody.rtmppublishurl)
}
inline void BeginToLiveRespBody::set_rtmppublishurl(const char* value, size_t size) {
  
  rtmppublishurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:BeginToLiveRespBody.rtmppublishurl)
}
inline ::std::string* BeginToLiveRespBody::mutable_rtmppublishurl() {
  
  // @@protoc_insertion_point(field_mutable:BeginToLiveRespBody.rtmppublishurl)
  return rtmppublishurl_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BeginToLiveRespBody::release_rtmppublishurl() {
  // @@protoc_insertion_point(field_release:BeginToLiveRespBody.rtmppublishurl)
  
  return rtmppublishurl_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BeginToLiveRespBody::set_allocated_rtmppublishurl(::std::string* rtmppublishurl) {
  if (rtmppublishurl != NULL) {
    
  } else {
    
  }
  rtmppublishurl_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), rtmppublishurl);
  // @@protoc_insertion_point(field_set_allocated:BeginToLiveRespBody.rtmppublishurl)
}

// string rtmpliveurl = 4;
inline void BeginToLiveRespBody::clear_rtmpliveurl() {
  rtmpliveurl_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& BeginToLiveRespBody::rtmpliveurl() const {
  // @@protoc_insertion_point(field_get:BeginToLiveRespBody.rtmpliveurl)
  return rtmpliveurl_.GetNoArena();
}
inline void BeginToLiveRespBody::set_rtmpliveurl(const ::std::string& value) {
  
  rtmpliveurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:BeginToLiveRespBody.rtmpliveurl)
}
#if LANG_CXX11
inline void BeginToLiveRespBody::set_rtmpliveurl(::std::string&& value) {
  
  rtmpliveurl_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:BeginToLiveRespBody.rtmpliveurl)
}
#endif
inline void BeginToLiveRespBody::set_rtmpliveurl(const char* value) {
  
  rtmpliveurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:BeginToLiveRespBody.rtmpliveurl)
}
inline void BeginToLiveRespBody::set_rtmpliveurl(const char* value, size_t size) {
  
  rtmpliveurl_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:BeginToLiveRespBody.rtmpliveurl)
}
inline ::std::string* BeginToLiveRespBody::mutable_rtmpliveurl() {
  
  // @@protoc_insertion_point(field_mutable:BeginToLiveRespBody.rtmpliveurl)
  return rtmpliveurl_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* BeginToLiveRespBody::release_rtmpliveurl() {
  // @@protoc_insertion_point(field_release:BeginToLiveRespBody.rtmpliveurl)
  
  return rtmpliveurl_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void BeginToLiveRespBody::set_allocated_rtmpliveurl(::std::string* rtmpliveurl) {
  if (rtmpliveurl != NULL) {
    
  } else {
    
  }
  rtmpliveurl_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), rtmpliveurl);
  // @@protoc_insertion_point(field_set_allocated:BeginToLiveRespBody.rtmpliveurl)
}

// -------------------------------------------------------------------

// EndLiveReqBody

// int64 time = 1;
inline void EndLiveReqBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 EndLiveReqBody::time() const {
  // @@protoc_insertion_point(field_get:EndLiveReqBody.time)
  return time_;
}
inline void EndLiveReqBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:EndLiveReqBody.time)
}

// -------------------------------------------------------------------

// EndLiveRespBody

// int64 time = 1;
inline void EndLiveRespBody::clear_time() {
  time_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 EndLiveRespBody::time() const {
  // @@protoc_insertion_point(field_get:EndLiveRespBody.time)
  return time_;
}
inline void EndLiveRespBody::set_time(::google::protobuf::int64 value) {
  
  time_ = value;
  // @@protoc_insertion_point(field_set:EndLiveRespBody.time)
}

// int64 liveid = 2;
inline void EndLiveRespBody::clear_liveid() {
  liveid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 EndLiveRespBody::liveid() const {
  // @@protoc_insertion_point(field_get:EndLiveRespBody.liveid)
  return liveid_;
}
inline void EndLiveRespBody::set_liveid(::google::protobuf::int64 value) {
  
  liveid_ = value;
  // @@protoc_insertion_point(field_set:EndLiveRespBody.liveid)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::DeviceType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::DeviceType>() {
  return ::DeviceType_descriptor();
}
template <> struct is_proto_enum< ::Command> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Command>() {
  return ::Command_descriptor();
}
template <> struct is_proto_enum< ::JoinGroupResult> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::JoinGroupResult>() {
  return ::JoinGroupResult_descriptor();
}
template <> struct is_proto_enum< ::ChatType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ChatType>() {
  return ::ChatType_descriptor();
}

}  // namespace protobuf
}  // namespace google
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_chat_2eproto__INCLUDED
